home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / xlisp_21.zoo / xlisp.mac < prev    next >
Internet Message Format  |  1990-02-28  |  27KB
  1. From sce!mitel!uunet!datapg!com50!pai!erc Tue Nov 14 08:51:33 EST 1989
  2. Article: 753 of comp.lang.scheme
  3. Path: cognos!sce!mitel!uunet!datapg!com50!pai!erc
  4. From: erc@pai.UUCP (Eric Johnson)
  5. Newsgroups: comp.lang.scheme,comp.sys.mac
  6. Subject: Re: How to build xscheme for the mac
  7. Summary: Hope this helps...
  8. Keywords: xscheme, mac
  9. Message-ID: <742@pai.UUCP>
  10. Date: 11 Nov 89 18:55:05 GMT
  11. References: <2091@cunixc.cc.columbia.edu>
  12. Organization: Prime Automation, Inc., Burnsville, MN
  13. Lines: 1374
  14. Xref: cognos comp.lang.scheme:753 comp.sys.mac:33459
  15.  
  16. In article <2091@cunixc.cc.columbia.edu>, puglia@cunixc.cc.columbia.edu (Paul Puglia) writes:
  17. > How does you build xscheme on a macintosh ? I have a copy of 
  18. > the xscheme sources compiles fine on a unix machine, and works
  19. > great on a pc with turbo c.  When I tried to compile it on a 
  20. > friends mac II using his copy of lightspeed c. I have no luck. 
  21. > Could someone please describe the procedure to compile this program, and
  22. > comment on if anything else is need to compile xscheme. I know that you 
  23. > need some resource to compile xlisp on a mac. Do you need the same sort of 
  24. > stuff for xscheme
  25. > Thanks in advance
  26. > Paul Puglia
  27. > Dept of Civil Engineering 
  28. > Columbia University
  29.  
  30.  
  31.  
  32. Porting Xlisp/XScheme:
  33.  
  34. Awhile back, while I was taking an AI course, I was spending a lot of time
  35. trekking to campus and using their LISP system.  To avoid travel time (and
  36. to work on LISP at any hour I wanted), I got into porting XLisp. In looking at 
  37. the code, I'd say XLisp and XScheme are two of the most portable C programs
  38. I have ever seen.  Now, I've spent most of my time on XLisp, so your
  39. mileage may vary, but...
  40.  
  41. XLisp seems to place most Operating System (OS)-dependent features in 
  42. separate files, named dosstuff.c, osptrs.h, osdefs.h.  On UNIX, the "stuff:
  43. file is called unixstuf.c and on the Mac its called macstuff.c (all file
  44. names are <= 8 chars for MS-DOS).  The mac version also has a resource
  45. compiler file (that is, a file you run through the resource compiler to
  46. generate a resource file).
  47.  
  48. I assume (hope) XScheme is similiar.  Below, I placed all my Mac-related
  49. files from XLisp (2.0, I think).  The XScheme stuff should be similiar.
  50. I hope these help.  (Note: I don't have the full sources around now, just
  51. the Mac and UNIX-specific files.)  (Note2: Two extra files, macfun.c and
  52. macinit.c are below, its been so long that I'm not sure if these are extras
  53. or necessary--Sorry.)
  54.  
  55. I'm placing these files here in hopes they can help you with your porting.  I
  56. do know that binary executable versions of XScheme are available on the
  57. BIX bulletin board (Byte magazine Information eXchange)--see Byte mag
  58. for details.  Getting the binaries would solve all the Mac porting
  59. problems in one fell swoop.
  60.  
  61. Anyway, hope this helps,
  62. -Eric
  63.  
  64.  
  65. ======================== macfun.c =============================================
  66.  
  67. /* macfun.c - macintosh user interface functions for xlisp */
  68.  
  69. #include <Quickdraw.h>
  70. #include <WindowMgr.h>
  71. #include <MemoryMgr.h>
  72. #include "xlisp.h"
  73.  
  74. /* external variables */
  75. extern GrafPtr cwindow,gwindow;
  76.  
  77. /* forward declarations */
  78. FORWARD LVAL do_0();
  79. FORWARD LVAL do_1();
  80. FORWARD LVAL do_2();
  81.  
  82. /* xptsize - set the command window point size */
  83. LVAL xptsize()
  84. {
  85.     LVAL val;
  86.     val = xlgafixnum();
  87.     xllastarg();
  88.     TextSize((int)getfixnum(val));
  89.     InvalRect(&cwindow->portRect);
  90.     SetupScreen();
  91.     return (NIL);
  92. }
  93.  
  94. /* xhidepen - hide the pen */
  95. LVAL xhidepen()
  96. {
  97.     return (do_0('H'));
  98. }
  99.  
  100. /* xshowpen - show the pen */
  101. LVAL xshowpen()
  102. {
  103.     return (do_0('S'));
  104. }
  105.  
  106. /* xgetpen - get the pen position */
  107. LVAL xgetpen()
  108. {
  109.     LVAL val;
  110.     Point p;
  111.     xllastarg();
  112.     SetPort(gwindow);
  113.     GetPen(&p);
  114.     SetPort(cwindow);
  115.     xlsave1(val);
  116.     val = consa(NIL);
  117.     rplaca(val,cvfixnum((FIXTYPE)p.h));
  118.     rplacd(val,cvfixnum((FIXTYPE)p.v));
  119.     xlpop();
  120.     return (val);
  121. }
  122.  
  123. /* xpenmode - set the pen mode */
  124. LVAL xpenmode()
  125. {
  126.     return (do_1('M'));
  127. }
  128.  
  129. /* xpensize - set the pen size */
  130. LVAL xpensize()
  131. {
  132.     return (do_2('S'));
  133. }
  134.  
  135. /* xpenpat - set the pen pattern */
  136. LVAL xpenpat()
  137. {
  138.     LVAL plist;
  139.     char pat[8],i;
  140.     plist = xlgalist();
  141.     xllastarg();
  142.     for (i = 0; i < 8 && consp(plist); ++i, plist = cdr(plist))
  143.     if (fixp(car(plist)))
  144.         pat[i] = getfixnum(car(plist));
  145.     SetPort(gwindow);
  146.     PenPat(pat);
  147.     SetPort(cwindow);
  148.     return (NIL);
  149. }
  150.  
  151. /* xpennormal - set the pen to normal */
  152. LVAL xpennormal()
  153. {
  154.     xllastarg();
  155.     SetPort(gwindow);
  156.     PenNormal();
  157.     SetPort(cwindow);
  158.     return (NIL);
  159. }
  160.  
  161. /* xmoveto - Move to a screen location */
  162. LVAL xmoveto()
  163. {
  164.     return (do_2('m'));
  165. }
  166.  
  167. /* xmove - Move in a specified direction */
  168. LVAL xmove()
  169. {
  170.     return (do_2('M'));
  171. }
  172.  
  173. /* xlineto - draw a Line to a screen location */
  174. LVAL xlineto()
  175. {
  176.     return (do_2('l'));
  177. }
  178.  
  179. /* xline - draw a Line in a specified direction */
  180. LVAL xline()
  181. {
  182.     return (do_2('L'));
  183. }
  184.  
  185. /* xshowgraphics - show the graphics window */
  186. LVAL xshowgraphics()
  187. {
  188.     xllastarg();
  189.     scrsplit(1);
  190.     return (NIL);
  191. }
  192.  
  193. /* xhidegraphics - hide the graphics window */
  194. LVAL xhidegraphics()
  195. {
  196.     xllastarg();
  197.     scrsplit(0);
  198.     return (NIL);
  199. }
  200.  
  201. /* xcleargraphics - clear the graphics window */
  202. LVAL xcleargraphics()
  203. {
  204.     xllastarg();
  205.     SetPort(gwindow);
  206.     EraseRect(&gwindow->portRect);
  207.     SetPort(cwindow);
  208.     return (NIL);
  209. }
  210.  
  211. /* do_0 - Handle commands that require no arguments */
  212. LOCAL LVAL do_0(fcn)
  213.   int fcn;
  214. {
  215.     xllastarg();
  216.     SetPort(gwindow);
  217.     switch (fcn) {
  218.     case 'H':    HidePen(); break;
  219.     case 'S':    ShowPen(); break;
  220.     }
  221.     SetPort(cwindow);
  222.     return (NIL);
  223. }
  224.  
  225. /* do_1 - Handle commands that require one integer argument */
  226. LOCAL LVAL do_1(fcn)
  227.   int fcn;
  228. {
  229.     int x;
  230.     x = getnumber();
  231.     xllastarg();
  232.     SetPort(gwindow);
  233.     switch (fcn) {
  234.     case 'M':    PenMode(x); break;
  235.     }
  236.     SetPort(cwindow);
  237.     return (NIL);
  238. }
  239.  
  240. /* do_2 - Handle commands that require two integer arguments */
  241. LOCAL LVAL do_2(fcn)
  242.   int fcn;
  243. {
  244.     int h,v;
  245.     h = getnumber();
  246.     v = getnumber();
  247.     xllastarg();
  248.     SetPort(gwindow);
  249.     switch (fcn) {
  250.     case 'l':    LineTo(h,v); break;
  251.     case 'L':    Line(h,v);   break;
  252.     case 'm':   MoveTo(h,v); break;
  253.     case 'M':    Move(h,v);   break;
  254.     case 'S':    PenSize(h,v);break;
  255.     }
  256.     SetPort(cwindow);
  257.     return (NIL);
  258. }
  259.  
  260. /* getnumber - get an integer parameter */
  261. LOCAL int getnumber()
  262. {
  263.     LVAL num;
  264.     num = xlgafixnum();
  265.     return ((int)getfixnum(num));
  266. }
  267.  
  268. /* xtool - call the toolbox */
  269. LVAL xtool()
  270. {
  271.     LVAL val;
  272.     int trap;
  273.  
  274.     trap = getnumber();
  275. /*
  276.  
  277.     asm {
  278.     move.l    args(A6),D0
  279.     beq    L2
  280. L1:    move.l    D0,A0
  281.     move.l    2(A0),A1
  282.     move.w    4(A1),-(A7)
  283.     move.l    6(A0),D0
  284.     bne    L1
  285. L2:    lea    L3,A0
  286.     move.w    trap(A6),(A0)
  287. L3:    dc.w    0xA000
  288.     clr.l    val(A6)
  289.     }
  290. */
  291.  
  292.     return (val);
  293. }
  294.  
  295. /* xtool16 - call the toolbox with a 16 bit result */
  296. LVAL xtool16()
  297. {
  298.     int trap,val;
  299.  
  300.     trap = getnumber();
  301. /*
  302.  
  303.     asm {
  304.     clr.w    -(A7)
  305.     move.l    args(A6),D0
  306.     beq    L2
  307. L1:    move.l    D0,A0
  308.     move.l    2(A0),A1
  309.     move.w    4(A1),-(A7)
  310.     move.l    6(A0),D0
  311.     bne    L1
  312. L2:    lea    L3,A0
  313.     move.w    trap(A6),(A0)
  314. L3:    dc.w    0xA000
  315.     move.w    (A7)+,val(A6)
  316.     }
  317. */
  318.  
  319.     return (cvfixnum((FIXTYPE)val));
  320. }
  321.  
  322. /* xtool32 - call the toolbox with a 32 bit result */
  323. LVAL xtool32()
  324. {
  325.     int trap;
  326.     long val;
  327.  
  328.     trap = getnumber();
  329. /*
  330.  
  331.     asm {
  332.     clr.l    -(A7)
  333.     move.l    args(A6),D0
  334.     beq    L2
  335. L1:    move.l    D0,A0
  336.     move.l    2(A0),A1
  337.     move.w    4(A1),-(A7)
  338.     move.l    6(A0),D0
  339.     bne    L1
  340. L2:    lea    L3,A0
  341.     move.w    trap(A6),(A0)
  342. L3:    dc.w    0xA000
  343.     move.l    (A7)+,val(A6)
  344.     }
  345. */
  346.  
  347.     return (cvfixnum((FIXTYPE)val));
  348. }
  349.  
  350. /* xnewhandle - allocate a new handle */
  351. LVAL xnewhandle()
  352. {
  353.     LVAL num;
  354.     long size;
  355.     num = xlgafixnum(); size = getfixnum(num);
  356.     xllastarg();
  357.     return (cvfixnum((FIXTYPE)NewHandle(size)));
  358. }
  359.  
  360. /* xnewptr - allocate memory */
  361. LVAL xnewptr()
  362. {
  363.     LVAL num;
  364.     long size;
  365.     num = xlgafixnum(); size = getfixnum(num);
  366.     xllastarg();
  367.     return (cvfixnum((FIXTYPE)NewPtr(size)));
  368. }
  369.     
  370. /* xhiword - return the high order 16 bits of an integer */
  371. LVAL xhiword()
  372. {
  373.     unsigned int val;
  374.     val = (unsigned int)(getnumber() >> 16);
  375.     xllastarg();
  376.     return (cvfixnum((FIXTYPE)val));
  377. }
  378.  
  379. /* xloword - return the low order 16 bits of an integer */
  380. LVAL xloword()
  381. {
  382.     unsigned int val;
  383.